package com.elcl.util.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author LCL
 * 线程池的使用
 * 1、CORE_POOL_SIZE就是实际运行的线程数（如果设置为1的话，当开启第二个线程的时候，便会到阻塞队列中等待）
 * 2、workQueue，当核心进程数满 的时候，便会到阻塞队列中等待（当阻塞队列中满的话，在和MAX_IMUM_POOL_SIZE的大小比较）
 * 3、MAX_IMUM_POOL_SIZE如果核心进程数满了，阻塞队列满了，就会开辟新的线程，如果开品的新线程的数目大于MAX_IMUM_POOL_SIZE，就会报错
 */
public class ThreadPoolUtils {
	final static int CORE_POOL_SIZE = 5;// 核心进程数
	final static int MAX_IMUM_POOL_SIZE = 10; // 线程池中的最大线程数
	final static int KEEP_ALIVE_TIME = 10 * 1000; //  额外线程空状态生存时间
	static ThreadPoolExecutor threadPool;

	// 阻塞队列。当核心线程都被占用，且阻塞队列已满的情况下，才会开启额外线程。
	static BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(
			10);

	//线程工厂，只是封装了一个线程的创建，符合工厂模式（并且符合下面线程池的创建参数）
	static ThreadFactory threadFactory = new ThreadFactory() {
		AtomicInteger integer = new AtomicInteger();
		@Override
		public Thread newThread(Runnable r) {
			return new Thread(r, "MyThread number" + integer.getAndIncrement());
		}
	};
	
	static {
		threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_IMUM_POOL_SIZE,
				KEEP_ALIVE_TIME, TimeUnit.SECONDS, workQueue, threadFactory);
	}

	public static void execute(Runnable runnable) {//线程整整执行的代码
		try{
			threadPool.execute(runnable);
		}catch(RejectedExecutionException e){
			
		}
	}
}
